feat: emit change events for local and remote changes, with corrections marked - #3413

…ions marked

Hosts had two ways to learn what the editor did to its content: the
per-operation `operation` feed, which has no notion of a user action and
no patches, and `mutation`, which carries patches but only on the
batcher's debounced flush and folds the editor's own normalization fixes
into the user's edit. Neither says "this action did these operations,
as these patches" at the moment the action finishes.

A change collector on the engine now groups applied operations into
`change` events. It records an entry for every operation when its apply
starts, since the `after` listeners of normalization fixes run before
the one of the operation that triggered them, and fills the entry with
the public operation and the local patches patch generation hands it.
Entries split by their apply-context frames: a `normalization` frame
while patching is a correction, a `remote` frame is remote, everything
else is an edit. The collector flushes when the outermost unit of work
returns: the depth-0 `behavior event` the editor machine performs, a
whole value sync (the sync machine's `syncValueCallback`), the
outermost `withRemoteChanges` bracket, or, for an apply outside all of
them, the outermost apply. A flush emits the unit's remote change
first, then its local entries in application order, each run of
consecutive edits or consecutive corrections as its own change. A
Behavior event whose action groups normalize in between therefore emits
edit, correction, edit, and replaying the patches in that order gives
the editor's value. A remote change goes out only when `isEqualValues`
finds the content after the unit differs from the content before its
first remote operation, so a remote `set` of a value the editor already
holds emits nothing. Entries are detached before any event is emitted,
so a listener that applies again starts a new change instead of adding
to one already delivered.

Unit depth is tracked with try/finally, apart from the apply depth the
operation listeners count. An apply that throws leaves the apply depth
raised; the outermost unit resets it on exit, and so does the next
apply that can only be outermost (no open unit and no `normalization`
frame, since only normalization re-enters `apply`). Remote operations
under the `initial-sync` source are dropped, so the first load emits
nothing, and the empty-editor placeholder insert runs under a new
`placeholder` frame and is never reported.

`isPublicOperation` moves from `create-editor.ts` to `types/operation.ts`
so the collector shares the `operation` event's allowlist. `mutation`,
`patch` and the batcher are unchanged.